package com.efast.dmom.mgmt.service.les.impl;

import com.efast.cafe.framework.exception.ServiceException;
import com.efast.cafe.framework.jdbc.JdbcDao;
import com.efast.cafe.framework.util.SpringWebUtils;
import com.efast.dmom.mgmt.bean.les.TtMmKanbanScanMriBean;
import com.efast.dmom.mgmt.dao.les.*;
import com.efast.dmom.mgmt.dao.master.*;
import com.efast.dmom.mgmt.entity.les.*;
import com.efast.dmom.mgmt.entity.master.*;
import com.efast.dmom.mgmt.service.les.TtMmKanbanscanMriService;
import com.efast.dmom.mgmt.utils.Assist;

import com.efast.dmom.mgmt.utils.MesConstant;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service
public class TtMmKanbanscanMriServiceImpl implements TtMmKanbanscanMriService {

    @Autowired
    private TtMmKanbanscanMriDao ttMmKanbanscanMriDao;

    // 看板上线单头表 tm_mm_delivery_sheet
    @Autowired
    private TmMmDeliverySheetDao tmMmDeliverySheetDao;

    // 看板上线单明细tm_mm_delivery_sheet_part
    @Autowired
    private TmMmDeliverySheetPartDao tmMmDeliverySheetPartDao;

    // 看板上线单历史记录 tm_mm_delivery_sheet_op
    @Autowired
    private TmMmDeliverySheetOpDao tmMmDeliverySheetOpDao;

    // 出库订单表 header
    @Autowired
    private TwDocOrderHeaderDao twDocOrderHeaderDao;

    // 出库订单表 detail
    @Autowired
    private TwDocOrderDetailsDao twDocOrderDetailsDao;

    // 【主数据】道口 tm_bas_dock
    @Autowired
    private TmBasDockDao tmBasDockDao;

    // 【主数据】零件供应商关系 tr_bas_part_suppl
    @Autowired
    private TrBasPartSupplDao trBasPartSupplDao;

    // 【主数据】零件基本信息 tm_bas_part
    @Autowired
    private TmBasPartDao tmBasPartDao;

    // 【主数据】仓库信息 tm_bas_workshop
	/*@Autowired
	private TmBasWorkshopDao tmBasWorkshopDao;*/

    // 【主数据】仓库信息 tm_bas_wh
    @Autowired
    private TmBasWhDao tmBasWhDao;

    // 【主数据】库区信息 tm_bas_dloc
    @Autowired
    private TmBasDlocDao tmBasDlocDao;

    // 【主数据】库位信息 tm_bas_loc
    @Autowired
    private TmBasLocDao tmBasLocDao;

    // 生成序列号
    @Qualifier("jdbcDao")
    @Autowired
    private JdbcDao jdbcDao;

    /**
     * 确认组单
     */
    @Override
    public void confirmBill(List<Map<String, Object>> listBean) {

        // 根据看板号，查询记录
        Assist assist = new Assist();
        for (int i = 0; i < listBean.size(); i++) {
            assist.setRequires(Assist.orEq("tt_mm_kanbanscan_mri.pull_unit_no", listBean.get(i).get("pullUnitNo")));
        }
        // 查询的结果按照  升序
        assist.setOrder(Assist.order("tt_mm_kanbanscan_mri.dpath_id", true));
        List<TtMmKanbanscanMri> listTtMmKanbanscanMri = ttMmKanbanscanMriDao.selectTtMmKanbanscanMri(assist);
        if (listTtMmKanbanscanMri.size() == 0) {
            throw new ServiceException("通过看板号无法查询到需求记录");
        }

        // 按照路径分组,组成单子.
        Map<String, Object> deliverySheetMap = null;
        Map<String, Object> orderHeaderMap = null;
        int tmMmDeliverySheetId = 0;
        for (int i = 0; i < listTtMmKanbanscanMri.size(); i++) {
            // 手工看板需求组织（tt_mm_manual_mri） 实体类
            TtMmKanbanscanMri ttMmManualMri = listTtMmKanbanscanMri.get(i);
            // 看板上线单头表 tm_mm_delivery_sheet 实体类
            TmMmDeliverySheet tmMmDeliverySheet1 = new TmMmDeliverySheet();
            BeanUtils.copyProperties(ttMmManualMri, tmMmDeliverySheet1);
            // 看板上线单明细tm_mm_delivery_sheet_part 实体类
            TmMmDeliverySheetPart tmMmDeliverySheetPart = new TmMmDeliverySheetPart();
            BeanUtils.copyProperties(ttMmManualMri, tmMmDeliverySheetPart);
            // 第一次的时候，需要向四张表都插入数据。
            if (i == 0) {
                // 【1:看板上线单头表 tm_mm_delivery_sheet】
                deliverySheetMap = insertNonEmptyTmMmDeliverySheet(ttMmManualMri, tmMmDeliverySheetPart,
                        tmMmDeliverySheet1);
                tmMmDeliverySheetId = tmMmDeliverySheet1.getTmMmDeliverySheetId();

                // 【2:看板上线单明细 tm_mm_delivery_sheet_part】
                int tmMmDeliverySheetPartId = insertNonEmptyTmMmDeliverySheetPart(ttMmManualMri, tmMmDeliverySheetPart, tmMmDeliverySheet1,
                        (int) deliverySheetMap.get("tmMmDeliverySheetId"));

                // 【3:发运订单（表头） tw_doc_order_header】 同时产生对应的出库订单header
                orderHeaderMap = insertNonEmptyTwDocOrderHeader(ttMmManualMri, tmMmDeliverySheetPart,
                        tmMmDeliverySheet1, deliverySheetMap);

                // 【4:发运订单（明细） tw_doc_order_details】 产生订单的detail
                deliverySheetMap.put("twDocOrderHeaderId", orderHeaderMap.get("twDocOrderHeaderId"));
                deliverySheetMap.put("tmMmDeliverySheetPartId", tmMmDeliverySheetPartId);
                deliverySheetMap.put("soSheetNo", orderHeaderMap.get("soSheetNo"));
                insertNonEmptyTwDocOrderDetails(ttMmManualMri, tmMmDeliverySheetPart, tmMmDeliverySheet1,
                        deliverySheetMap);

                // 【5：产生单据的同时，产生历史记录信息】
                insertNonEmptyTmMmDeliverySheetOp(tmMmDeliverySheetId);
            } else {
                // 第二次的时候需要判断前后记录路径是否相同
                // 如果当前的记录的路径ID和前面一条记录的路径ID相等，则说明两条记录是同一个路径ID，此时只需要插入detail记录，不需要插入头记录。
                if (listTtMmKanbanscanMri.get(i).getDpathId() == listTtMmKanbanscanMri.get(i - 1).getDpathId() ||
                        (listTtMmKanbanscanMri.get(i).getDpathId()).equals(listTtMmKanbanscanMri.get(i - 1).getDpathId())) {
                    // 【2:看板上线单明细 tm_mm_delivery_sheet_part】
                    int tmMmDeliverySheetPartId = insertNonEmptyTmMmDeliverySheetPart(ttMmManualMri, tmMmDeliverySheetPart, tmMmDeliverySheet1,
                            tmMmDeliverySheetId);

                    // 【4:发运订单（明细） tw_doc_order_details】 产生订单的detail
                    deliverySheetMap.put("tmMmDeliverySheetPartId", tmMmDeliverySheetPartId);
                    insertNonEmptyTwDocOrderDetails(ttMmManualMri, tmMmDeliverySheetPart, tmMmDeliverySheet1,
                            deliverySheetMap);

                } else {
                    deliverySheetMap.clear();
                    orderHeaderMap.clear();
                    // 【1:看板上线单头表 tm_mm_delivery_sheet】
                    deliverySheetMap = insertNonEmptyTmMmDeliverySheet(ttMmManualMri, tmMmDeliverySheetPart,
                            tmMmDeliverySheet1);
                    tmMmDeliverySheetId = tmMmDeliverySheet1.getTmMmDeliverySheetId();

                    // 【2:看板上线单明细 tm_mm_delivery_sheet_part】
                    int tmMmDeliverySheetPartId = insertNonEmptyTmMmDeliverySheetPart(ttMmManualMri, tmMmDeliverySheetPart, tmMmDeliverySheet1,
                            (int) deliverySheetMap.get("tmMmDeliverySheetId"));

                    // 【3:发运订单（表头） tw_doc_order_header】 同时产生对应的出库订单header
                    orderHeaderMap = insertNonEmptyTwDocOrderHeader(ttMmManualMri, tmMmDeliverySheetPart,
                            tmMmDeliverySheet1, deliverySheetMap);

                    // 【4:发运订单（明细） tw_doc_order_details】 产生订单的detail
                    deliverySheetMap.put("soSheetNo", orderHeaderMap.get("soSheetNo"));
                    deliverySheetMap.put("tmMmDeliverySheetPartId", tmMmDeliverySheetPartId);
                    deliverySheetMap.put("twDocOrderHeaderId", orderHeaderMap.get("twDocOrderHeaderId"));
                    insertNonEmptyTwDocOrderDetails(ttMmManualMri, tmMmDeliverySheetPart, tmMmDeliverySheet1,
                            deliverySheetMap);

                    // 【5：产生单据的同时，产生历史记录信息】
                    insertNonEmptyTmMmDeliverySheetOp(tmMmDeliverySheetId);
                }
            }
        }

        // 组单成功，更细状态
        for (TtMmKanbanscanMri ttMmKanbanscanMri : listTtMmKanbanscanMri) {
            TtMmKanbanscanMri ttMmKanbanscanMri1 = new TtMmKanbanscanMri();
            ttMmKanbanscanMri1.setTtMmKanbanscanMriId(ttMmKanbanscanMri.getTtMmKanbanscanMriId());
            ttMmKanbanscanMri1.setMriStatus("1");// 物料需求信息状态((0;未组织，1已组织，2组织失败)
            ttMmKanbanscanMriDao.updateNonEmptyTtMmKanbanscanMriById(ttMmKanbanscanMri1);
        }
    }

    public Map<String, Object> insertNonEmptyTmMmDeliverySheet(TtMmKanbanscanMri ttMmKanbanscanMri,
                                                               TmMmDeliverySheetPart tmMmDeliverySheetPart, TmMmDeliverySheet tmMmDeliverySheet1) {
        String sheetNo = jdbcDao.executeProcGetCode("tm_mm_delivery_sheet", "efast");
        tmMmDeliverySheet1.setSheetNo(sheetNo);// 单号
        tmMmDeliverySheet1.setCommonSheetType("14"); // 对应单证类型14看板上线指示单15看板补货指示单
        tmMmDeliverySheet1.setIsEmergent(1); // 是否紧急拉动单0否1是 默认都是1
        tmMmDeliverySheet1.setSheetStatus("1");// 需求单状态（0新单1发布2部分上线3上线完成4上线失败）
        tmMmDeliverySheet1.setPrintStatus("0");// 打印状态0未打印1已打印
        tmMmDeliverySheet1.setMarkStatus(1);
        tmMmDeliverySheet1.setCreateUser(SpringWebUtils.getRequestUser());
        tmMmDeliverySheetDao.insertNonEmptyTmMmDeliverySheet(tmMmDeliverySheet1);
        Map<String, Object> returnMap = new HashMap<>();
        returnMap.put("tmMmDeliverySheetId", tmMmDeliverySheet1.getTmMmDeliverySheetId());
        returnMap.put("sheetNo", sheetNo);
        return returnMap;
    }

    public void insertNonEmptyTmMmDeliverySheetOp(int tmMmDeliverySheetId) {
        TmMmDeliverySheetOp tmMmDeliverySheetOp = new TmMmDeliverySheetOp();
        tmMmDeliverySheetOp.setTmMmDeliverySheetId(tmMmDeliverySheetId);
        tmMmDeliverySheetOp.setCreateTime(new Date());
        tmMmDeliverySheetOp.setCompanyCode(SpringWebUtils.getRequestCompany());
        tmMmDeliverySheetOp.setCreateUser(SpringWebUtils.getRequestUser());
        tmMmDeliverySheetOp.setOperateNotes("已发布");// 操作备注
        tmMmDeliverySheetOp.setCommonSheetOpType("1");// 拣配单操作类型  需求单状态（0新单1发布2部分上线3上线完成4上线失败）
        tmMmDeliverySheetOp.setOperateUsername(SpringWebUtils.getRequestUser());
        tmMmDeliverySheetOp.setMarkStatus(1);
        tmMmDeliverySheetOpDao.insertNonEmptyTmMmDeliverySheetOp(tmMmDeliverySheetOp);
    }

    public int insertNonEmptyTmMmDeliverySheetPart(TtMmKanbanscanMri ttMmKanbanscanMri,
                                                   TmMmDeliverySheetPart tmMmDeliverySheetPart, TmMmDeliverySheet tmMmDeliverySheet1,
                                                   int tmMmDeliverySheetId) {
        tmMmDeliverySheetId = tmMmDeliverySheet1.getTmMmDeliverySheetId();
        tmMmDeliverySheetPart.setTmMmDeliverySheetId(tmMmDeliverySheetId);// 设置detail的关联外键
        tmMmDeliverySheetPart.setMapType("0"); // 对应零件类型\r\n默认都是0 普通零件 因为没有组合零件
        tmMmDeliverySheetPart.setItemStatus("1");// tem状态0新单1已发布
        tmMmDeliverySheetPart.setLinePackageNo(ttMmKanbanscanMri.getSendPackageNo());
        tmMmDeliverySheetPart.setReqBoxnum(ttMmKanbanscanMri.getReqPackageNum());
        tmMmDeliverySheetPart.setStationArriveTime(ttMmKanbanscanMri.getReqArriveTime());
        tmMmDeliverySheetPart.setLinePackageQty(ttMmKanbanscanMri.getSendPackageNum());
        tmMmDeliverySheetPart.setMarkStatus(1);
        tmMmDeliverySheetPart.setCreateUser(SpringWebUtils.getRequestUser());
        tmMmDeliverySheetPartDao.insertNonEmptyTmMmDeliverySheetPart(tmMmDeliverySheetPart);
        return tmMmDeliverySheetPart.getTmMmDeliverySheetPartId();
    }

    public Map<String, Object> insertNonEmptyTwDocOrderHeader(TtMmKanbanscanMri ttMmKanbanscanMri,
                                                              TmMmDeliverySheetPart tmMmDeliverySheetPart, TmMmDeliverySheet tmMmDeliverySheet1,
                                                              Map<String, Object> map) {
        // 【3:发运订单（表头） tw_doc_order_header】 同时产生对应的出库订单header
        TwDocOrderHeader twDocOrderHeader = new TwDocOrderHeader();
        twDocOrderHeader.setDockId(tmMmDeliverySheet1.getSendDockId());
        TmBasDock tmBasDock = tmBasDockDao.selectTmBasDockById(tmMmDeliverySheet1.getSendDockId());
        twDocOrderHeader.setDockNo(tmBasDock.getDockNo());
        twDocOrderHeader.setCommonSheetType("999"); // common_sheet_type 赋值为999
        String soSheetNo = jdbcDao.executeProcGetCode("tw_doc_order_header", "efast");
        twDocOrderHeader.setSoSheetNo(soSheetNo);
        twDocOrderHeader.setSoSheetStatus("0"); // SO单证状态（新单0、部分分配1、分配完成2、部分拣货3、拣货完成4、部分装箱5、装箱完成6、部分发运7、发运完成8、订单取消9、单证关闭10）
        twDocOrderHeader.setSoSendTime(tmMmDeliverySheet1.getReqArriveTime());
        twDocOrderHeader.setDeliverySend(tmMmDeliverySheet1.getDeliverySend());// 发运地
        twDocOrderHeader.setDeliveryRec(tmMmDeliverySheet1.getDeliveryRec()); // 目的地
        twDocOrderHeader.setCustSheetId((String) map.get("sheetNo"));
        twDocOrderHeader.setCustSheetType("14");
        twDocOrderHeader.setCreateUserType("0");// 创建用户类型(系统自动0，人工1)
        twDocOrderHeader.setMarkStatus(1);
        twDocOrderHeader.setCreateTime(new Date());
        twDocOrderHeader.setCreateUser(SpringWebUtils.getRequestUser());
        twDocOrderHeader.setCompanyCode(SpringWebUtils.getRequestCompany());
        twDocOrderHeaderDao.insertNonEmptyTwDocOrderHeader(twDocOrderHeader);
        Map<String, Object> map1 = new HashMap<>();
        map1.put("dockNo", tmBasDock.getDockNo());
        map1.put("twDocOrderHeaderId", twDocOrderHeader.getTwDocOrderHeaderId());
        map1.put("soSheetNo", soSheetNo);
        return map1;
    }

    public void insertNonEmptyTwDocOrderDetails(TtMmKanbanscanMri ttMmKanbanscanMri,
                                                TmMmDeliverySheetPart tmMmDeliverySheetPart, TmMmDeliverySheet tmMmDeliverySheet1,
                                                Map<String, Object> map) {
        // tmMmDeliverySheet1.setDeliveryUserId(deliveryUserId); // 送料人ID 上线的时候更新进去
        // 【4:发运订单（明细） tw_doc_order_details】 产生订单的detail
        TwDocOrderDetails twDocOrderDetails = new TwDocOrderDetails();
        twDocOrderDetails.setCustomerid(MesConstant.DELIVERY_UNIT_NO);
        List<TwDocOrderDetails> list = twDocOrderDetailsDao.selectTwDocOrderDetails(new Assist(
                Assist.andEq("tw_doc_order_details.tw_doc_order_header_id", (int) map.get("twDocOrderHeaderId"))));
        if (list.size() == 0) {
            twDocOrderDetails.setSoLineno(1); // 行号
        } else {
            twDocOrderDetails.setSoLineno(list.size() + 1); // 行号
        }
        twDocOrderDetails.setLineStatus("0");// 订单行状态（新单0、部分分配1、分配完成2、部分拣货3、拣货完成4、订单取消9、关闭10、分配失败11）
        TrBasPartSuppl trBasPartSuppl = trBasPartSupplDao
                .selectTrBasPartSupplById(tmMmDeliverySheetPart.getTrBasPartSupplId());
        List<TmBasPart> listTmBasPart = tmBasPartDao.selectTmBasPart(
                new Assist(Assist.andEq("tm_bas_part.part_no_version", trBasPartSuppl.getPartNoVersion()),
                        Assist.andEq("tm_bas_part.plant_no", trBasPartSuppl.getPlantNo()),
                        Assist.andEq("tm_bas_part.workshop_no", trBasPartSuppl.getWorkshopNo())));
        TmBasPart tmBasPart = listTmBasPart.get(0);
        twDocOrderDetails.setPartNamee(tmBasPart.getPartNameE()); // 零件英文名称
        twDocOrderDetails.setTwDocOrderHeaderId((int) map.get("twDocOrderHeaderId"));
        twDocOrderDetails.setPartNoVersion(trBasPartSuppl.getPartNoVersion());// 零件号
        twDocOrderDetails.setPartNamec(tmBasPart.getPartNameC());// 零件中文名称
        twDocOrderDetails.setBaseUnit(tmBasPart.getBaseUnit());// 零件基本单位
        twDocOrderDetails.setSoReqQty(tmMmDeliverySheetPart.getReqQty());// 要求发货数量
        twDocOrderDetails.setSoPackageNo(tmMmDeliverySheetPart.getLinePackageNo());// 要求发货包装编号
        twDocOrderDetails.setSoPackageNum(tmMmDeliverySheetPart.getReqBoxnum()); // '要求发货箱数
        twDocOrderDetails.setCustSheetId((String) map.get("sheetNo"));
        twDocOrderDetails.setCustSheetType("14");
        twDocOrderDetails.setCustSheetLineId(tmMmDeliverySheetPart.getTmMmDeliverySheetPartId());
        twDocOrderDetails.setSoSheetNo((String) map.get("soSheetNo")); // SO单号',【header】
        twDocOrderDetails.setSoPackageQty(tmMmDeliverySheetPart.getLinePackageQty()); // 要求发货包装容量
        twDocOrderDetails.setSupplNo(trBasPartSuppl.getSupplNo());
        twDocOrderDetails.setSoSendTime(tmMmDeliverySheetPart.getStationArriveTime());
        twDocOrderDetails.setDockId(tmMmDeliverySheet1.getSendDockId());
        twDocOrderDetails.setDockNo((String) map.get("dockNo"));// 发货道口编号',【要查的】
        twDocOrderDetails.setItemLoadStatus("0");// 状态（发运任务未产生0、发运任务产生1、部分发运2、发运完成3）',【默认0】
        twDocOrderDetails.setDeliverySend(tmMmDeliverySheet1.getDeliverySend());// 发运地
        twDocOrderDetails.setDeliveryRec(tmMmDeliverySheet1.getDeliveryRec());// 目的地
        twDocOrderDetails.setTrBasPartSupplId(tmMmDeliverySheetPart.getTrBasPartSupplId());// 零件供应商关系id
        List<TmBasWh> listTmBasWorkshop = tmBasWhDao.selectTmBasWh(
                new Assist(Assist.andEq("tm_bas_wh.storage_no", tmMmDeliverySheetPart.getWarehouseNo())));
        List<TmBasDloc> listTmBasDloc = tmBasDlocDao
                .selectTmBasDloc(new Assist(Assist.andEq("tm_bas_dloc.storage_no", tmMmDeliverySheetPart.getDlocNo())));
        List<TmBasLoc> listTmBasLoc = tmBasLocDao
                .selectTmBasLoc(new Assist(Assist.andEq("tm_bas_loc.storage_no", tmMmDeliverySheetPart.getLocNo())));
        twDocOrderDetails.setpFromWarehouseId(listTmBasWorkshop.get(0).getTmBasWhId());// 来源仓库ID
        twDocOrderDetails.setpFromDlocId(listTmBasDloc.get(0).getTmBasDlocId());// 来源库区ID
        twDocOrderDetails.setpFromLocId(listTmBasLoc.get(0).getTmBasLocId()); // 来源库位ID
        twDocOrderDetails.setpFromWarehouseNo(tmMmDeliverySheetPart.getWarehouseNo());// 来源仓库编号
        twDocOrderDetails.setpFromDlocNo(tmMmDeliverySheetPart.getDlocNo());// 来源库区编号'
        twDocOrderDetails.setpFromLocNo(tmMmDeliverySheetPart.getLocNo());// 来源库位编号
        twDocOrderDetails.setMarkStatus(1);
        twDocOrderDetails.setCreateTime(new Date());
        twDocOrderDetails.setCreateUser(SpringWebUtils.getRequestCompany());
        twDocOrderDetailsDao.insertNonEmptyTwDocOrderDetails(twDocOrderDetails);
    }


    @Override
    public long getTtMmKanbanscanMriRowCount(Assist assist) {
        return ttMmKanbanscanMriDao.getTtMmKanbanscanMriRowCount(assist);
    }

    @Override
    public List<TtMmKanbanscanMri> selectTtMmKanbanscanMri(Assist assist) {
        return ttMmKanbanscanMriDao.selectTtMmKanbanscanMri(assist);
    }

    @Override
    public TtMmKanbanscanMri selectTtMmKanbanscanMriByObj(TtMmKanbanscanMri obj) {
        return ttMmKanbanscanMriDao.selectTtMmKanbanscanMriByObj(obj);
    }

    @Override
    public TtMmKanbanscanMri selectTtMmKanbanscanMriById(Integer id) {
        return ttMmKanbanscanMriDao.selectTtMmKanbanscanMriById(id);
    }

    @Override
    public int insertTtMmKanbanscanMri(TtMmKanbanscanMri value) {
        return ttMmKanbanscanMriDao.insertTtMmKanbanscanMri(value);
    }

    @Override
    public int insertNonEmptyTtMmKanbanscanMri(TtMmKanbanscanMri value) {
        return ttMmKanbanscanMriDao.insertNonEmptyTtMmKanbanscanMri(value);
    }

    @Override
    public int insertTtMmKanbanscanMriByBatch(List<TtMmKanbanscanMri> value) {
        return ttMmKanbanscanMriDao.insertTtMmKanbanscanMriByBatch(value);
    }

    @Override
    public int deleteTtMmKanbanscanMriById(Integer id) {
        return ttMmKanbanscanMriDao.deleteTtMmKanbanscanMriById(id);
    }

    @Override
    public int deleteTtMmKanbanscanMri(Assist assist) {
        return ttMmKanbanscanMriDao.deleteTtMmKanbanscanMri(assist);
    }

    @Override
    public int updateTtMmKanbanscanMriById(TtMmKanbanscanMri enti) {
        return ttMmKanbanscanMriDao.updateTtMmKanbanscanMriById(enti);
    }

    @Override
    public int updateTtMmKanbanscanMri(TtMmKanbanscanMri value, Assist assist) {
        return ttMmKanbanscanMriDao.updateTtMmKanbanscanMri(value, assist);
    }

    @Override
    public int updateNonEmptyTtMmKanbanscanMriById(TtMmKanbanscanMri enti) {
        return ttMmKanbanscanMriDao.updateNonEmptyTtMmKanbanscanMriById(enti);
    }

    @Override
    public int updateNonEmptyTtMmKanbanscanMri(TtMmKanbanscanMri value, Assist assist) {
        return ttMmKanbanscanMriDao.updateNonEmptyTtMmKanbanscanMri(value, assist);
    }

    /**
     * 扫描看板卡号查询相关的数据，并且插入到tt_mm_kanbanscan_mri
     *
     * @param reqTtMmKanbanscanMri
     *            ttMmKanbanscanMri
     * @return TtMmKanbanscanMri
     */
    @Override
    public TtMmKanbanscanMri selectReplenishmentTtMmManualMriByObj(TtMmKanbanscanMri reqTtMmKanbanscanMri) {
        // 【1】 判断tt_mm_manual_mri表是否已经存在看板号
        List<TtMmKanbanscanMri> list = ttMmKanbanscanMriDao.selectTtMmKanbanscanMri(
                new Assist(Assist.andEq("tt_mm_kanbanscan_mri.pull_unit_no", reqTtMmKanbanscanMri.getPullUnitNo())));
        if (list.size() > 0) {
            throw new ServiceException("不难重复扫描看板卡号==>" + reqTtMmKanbanscanMri.getPullUnitNo() + "");
        }
        // 【2】 通过看板号 查询出这个看板号相关的信息。
        List<TtMmKanbanScanMriBean> listTtMmManualMriBean = ttMmKanbanscanMriDao.queryReplenishmentInfoByPullUnitNo(
                reqTtMmKanbanscanMri.getPullUnitNo());
        if (listTtMmManualMriBean.size() == 0) {
            throw new ServiceException("找不到看板卡号==>" + reqTtMmKanbanscanMri.getPullUnitNo() + "");
        }
        TtMmKanbanScanMriBean ttMmKanbanScanMriBean = listTtMmManualMriBean.get(0);
        // 【3】将该条记录插入到tt_mm_manual_mri表中。
        TtMmKanbanscanMri ttMmKanbanscanMri = new TtMmKanbanscanMri();
        ttMmKanbanscanMri.setCollectTime(new Date()); // 采集时间
        ttMmKanbanscanMri.setComboFlag("0"); // 是否需要组织对外配送指令(0需组织1不需组织) 默认都是0
        ttMmKanbanscanMri.setDeliverStatus("0"); // 配送指令组织状态(0;未组织，1已组织，2组织失败)
        BeanUtils.copyProperties(ttMmKanbanScanMriBean, ttMmKanbanscanMri);
        long time = System.currentTimeMillis() + ttMmKanbanScanMriBean.getReqArriveTimeInt() * 60 * 1000;
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        String date = sdf.format(new Date(time));
        try {
            ttMmKanbanscanMri.setReqArriveTime(sdf.parse(date));
        } catch (ParseException e) {
            e.printStackTrace();
            throw new ServiceException("要求送货时间 转换异常");
        }
        // 需求数量=上线包装容量*拉动批量
        Integer needCount = ttMmKanbanScanMriBean.getReqQty() * ttMmKanbanScanMriBean.getPullQty();
        ttMmKanbanscanMri.setReqQty(needCount);
        double reqPackageNum = needCount % ttMmKanbanScanMriBean.getSendPackageNum();
        if (reqPackageNum == 0) {
            ttMmKanbanscanMri.setReqPackageNum(needCount / ttMmKanbanScanMriBean.getSendPackageNum()); // 需求箱数（以发运包装计算）
        } else {
            ttMmKanbanscanMri.setReqPackageNum(needCount / ttMmKanbanScanMriBean.getSendPackageNum() + 1); // 需求箱数（以发运包装计算）
        }
        ttMmKanbanscanMri.setPullType("2"); // 看板模式(上线看板-1，补货看板-2)
        ttMmKanbanscanMri.setComboFlag("0"); // 是否需要组织对外配送指令(0需组织1不需组织) 默认都是0
        ttMmKanbanscanMri.setMriStatus("0");// 物料需求信息状态((0;未组织，1已组织，2组织失败)
        ttMmKanbanscanMri.setDeliverStatus("0"); // 配送指令组织状态(0;未组织，1已组织，2组织失败)
        ttMmKanbanscanMri.setSendStationNo(ttMmKanbanScanMriBean.getLocNo());// 送货工位编号
        ttMmKanbanscanMri.setDareaNo(ttMmKanbanScanMriBean.getDareaNo());// 送货区域编号
        ttMmKanbanscanMri.setUseStationNo(ttMmKanbanScanMriBean.getLocNo());// 使用工位
        ttMmKanbanscanMri.setMriCreateUsername(SpringWebUtils.getRequestUser());
        ttMmKanbanscanMri.setCreateTime(new Date());
        ttMmKanbanscanMri.setCreateUser(SpringWebUtils.getRequestUser());
        ttMmKanbanscanMri.setCompanyCode(SpringWebUtils.getRequestCompany());
        ttMmKanbanscanMriDao.insertNonEmptyTtMmKanbanscanMri(ttMmKanbanscanMri);
        // 【4】将查询出来的记录返回给前台，前台可能会修改 “需求数量”.需求箱数需要自动修改.
        return ttMmKanbanscanMri;
    }
}